#ifndef __M_UTIL_H__
#define __M_UTIL_H__

#include "logger.hpp"
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <memory>  // 智能指针
#include <vector>
#include <cstdint>

#include <mysql/mysql.h>

#include <jsoncpp/json/json.h>

class mysql_util {
public:
    // 初始化句柄的函数
    static MYSQL *mysql_create(const std::string &host,
        const std::string &username,
        const std::string &password,
        const std::string &dbname,
        uint16_t port = 3306) {
        MYSQL *mysql = mysql_init(NULL);
        if (mysql == NULL) {
            ELOG("mysql init failed!");
            return NULL;
        }
        //2. 连接服务器
        if (mysql_real_connect(mysql, 
            host.c_str(), 
            username.c_str(), 
            password.c_str(), 
            dbname.c_str(), port, NULL, 0) == NULL) {
            ELOG("connect mysql server failed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }
        //3. 设置客户端字符集
        if (mysql_set_character_set(mysql, "utf8") != 0) {
            ELOG("set client character failed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }
        return mysql;
    }

    // 执行指令的函数
    static bool mysql_exec(MYSQL *mysql, const std::string &sql) {
        int ret = mysql_query(mysql, sql.c_str());
        if (ret != 0) {
            ELOG("%s\n", sql.c_str());
            ELOG("mysql query failed : %s\n", mysql_error(mysql));
            return false;
        }
        return true;
    }

    // 销毁句柄的函数
    static void mysql_destroy(MYSQL *mysql) {
        if (mysql != NULL) {
            mysql_close(mysql);
        }
        return ;
    }
};

class json_util{
public:
    // 序列化函数
    static bool serialize(const Json::Value &root, std::string &str){
        // 实例化一个StreamWriterBuilder工厂类对象
        Json::StreamWriterBuilder swb;
        // 通过StreamWriterBuilder工厂类对象生产一个StreamWriter对象
        std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
        // 使用StreamWriter对象，对Json::Value中存储的数据进行序列化
        std::stringstream ss;
        int ret = sw->write(root, &ss);
        if(ret != 0){
            ELOG("json serialize failed!");
            return false;
        }

        str = ss.str();

        return true;
    }

    // 反序列化函数
    static bool unserialize(const std::string& str, Json::Value &root){
        // 实例化一个CharReaderBuilder工厂类对象
        Json::CharReaderBuilder crb;
        // 使用CharReaderBuilder工厂类生产一个CharReader对象
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
        // 使用CharReader对象进行json格式字符串str的反序列化
        std::string err;
        bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root, &err);
        if(ret == false){
            ELOG("json unserialize failed: %s", err.c_str());
            return false;
        }

        return true;
    }
};

class string_util{
public:
    // 字符串分割函数
    static int split(const std::string &src, const std::string& sep, std::vector<std::string> &res){
        // 123,456,,,789  找分隔符 sep
        size_t pos, idx = 0;

        while(idx < src.size()){
            pos = src.find(sep, idx);   // 从 src 的 0 下标开始找 sep
            if(pos == std::string::npos){
                // 没有找到的情况, src 中没有 sep 字符串了
                res.push_back(src.substr(idx));
                break ;
            }
            // pos - idx 是截取字符的长度
            if(pos == idx){ // 空字符串 continue
                idx += sep.size();
                continue;
            }
            res.push_back(src.substr(idx, pos - idx));
            idx = pos + sep.size();  // 记得加上 sep.size() 目的是跳过 sep 分隔符
        }
    
        return res.size();  // 返回截取了多少个字符串
    }
};

class file_util{
public:
    // 读取文件数据的函数
    // 读取的数据放入到 body 里面去
    static bool read(const std::string &filename, std::string &body){
        // 打开文件   
        std::ifstream ifs(filename, std::ios::binary);
        if(ifs.is_open() == false){
            ELOG("%s file open failed!", filename.c_str());
            return false;
        }

        // 获取文件大小
        size_t fsize = 0;
        ifs.seekg(0, std::ios::end);  // 寻找尾部
        fsize = ifs.tellg();
        ifs.seekg(0, std::ios::beg);  // 寻找头部
        body.resize(fsize);

        // 将文件所有数据读取出来
        // ifs.read(body.c_str(), fsize);  // 这样是不行的哦，因为这样的是body是不允许被改的
        ifs.read(&body[0], fsize);
        if(ifs.good() == false){
            ELOG("read %s file content failed!", filename.c_str());
            ifs.close();
            return false;
        }

        // 关闭文件
        ifs.close();
        
        return true;
    }
};

#endif


/*
// mysql_util 的测试：
#define HOST "127.0.0.1"    // 设置只能本地登录
#define PORT 3306           // 默认就是3306
#define USER "root"         // root 用户登录
#define PASS "ax020913"     // root 登录 mysql 的密码
#define DBNAME "gobang"     // 我们刚刚创建的 gobang 数据库

int main(void){
    MYSQL* mysql = mysql_util::mysql_create(HOST, USER, PASS, DBNAME, PORT);
    const char* sql = "insert stu value(null, '小明', 18, 53, 68, 87);";
    bool ret = mysql_util::mysql_exec(mysql, sql);
    if(ret == false)
        return -1;
    mysql_util::mysql_destroy(mysql);

    return 0;
}
*/

/*
// json_util 的测试：
int main(void){
    // 序列化
    // 将需要进行序列化的数据，存储在Json::Value 对象中
    Json::Value root;
    std::string body;
    root["姓名"] = "小敏";
    root["年龄"] = 20;
    // 因为成绩的话有几个学科的成绩，所以是一个数组存储。数组添加元素得用append接口的哦
    root["成绩"].append(89);  
    root["成绩"].append(89.4);
    root["成绩"].append(96);
    json_util::serialize(root, body);
    // DLOG(body.c_str());     // 这样写是有问题的哦
    DLOG("%s", body.c_str());  // DBUG 类型的日志

    // 反序列化
    Json::Value val;
    json_util::unserialize(body, val);
    // 逐个元素去访问Json::Value中的数据
    std::cout << "姓名 " << val["姓名"].asString() << std::endl;
    std::cout << "年龄 " << val["年龄"].asInt() << std::endl;
    int cnt = val["成绩"].size();
    for(int i = 0; i < cnt; i++)
        std::cout << "成绩 " << val["成绩"][i].asFloat() << std::endl;

    return 0;
}
*/

/*
// string_util 的测试：
int main(void){
    std::string str = "123,234,,,,,345,,,,";
    std::string sep = ",";
    std::vector<std::string> array;

    string_util::split(str, sep, array);
    for(auto s: array)
        DLOG("%s", s.c_str());

    return 0;
}
*/


/*
// file_util 的测试：
int main(void){
    std::string filename = "./makefile";
    std::string body;
    bool ret = file_util::read(filename, body);

    std::cout << body << std::endl;

    return 0;
}
*/
